home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Topik / Topik - Disk 24 - Productivity (19xx)(Topik Public Domain)(PD)[WB].zip / Topik - Disk 24 - Productivity (19xx)(Topik Public Domain)(PD)[WB].adf / Calendar / schedule.c < prev    next >
C/C++ Source or Header  |  1990-01-31  |  9KB  |  485 lines
  1. /*#include <curses.h>*/
  2. #include "month.h"
  3.  
  4. struct event_rec events = {0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  5. 0, 0, 0, 0, 0, 0, 0, 0, 0};
  6. struct event_rec current_event = {0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0},
  7. 1, 0, 0, 10, 0, 1, 0, "", 0};
  8. short update_schedule = 0;
  9. short updating = 0, edit_flag = 0, put_into_schedule, parsed_correctly;
  10. char schedule_file_name[75];
  11. short SCHEDULE_ROW;
  12.  
  13. char *grids[] = {
  14. "mid.  .  .  1a .  .  .  2a .  .  .  3a .  .  .  4a .  .  .  5a .  .  .  6a",
  15. "6a .  .  .  7a .  .  .  8a .  .  .  9a .  .  .  10a.  .  .  11a.  .  .  noon",
  16. "noon  .  .  1p .  .  .  2p .  .  .  3p .  .  .  4p .  .  .  5p .  .  .  6p",
  17. "6p .  .  .  7p .  .  .  8p .  .  .  9p .  .  .  10p.  .  .  11p.  .  .  mid"
  18. };
  19. extern short month, day, year, days;
  20.  
  21. post_event(month, day, year)
  22. short month, day, year;
  23. {
  24.     goto_schedule();
  25.     current_event.event_month = month;
  26.     current_event.event_day = day;
  27.     current_event.event_year = year;
  28.     display_event(¤t_event);
  29. }
  30.  
  31. read_schedule()
  32. {
  33.     char *getenv(), *malloc(), *s;
  34.     int fd, rec_size;
  35.     struct event_rec event_buf, *event_ptr, *chain_ptr;
  36.  
  37.     chain_ptr = events.next_event;  /* free old events */
  38.     while (chain_ptr) {
  39.         event_ptr = chain_ptr;
  40.         chain_ptr = chain_ptr->next_event;
  41.         free(event_ptr);
  42.     }
  43.     events.next_event = 0;
  44.  
  45.     if (!(s = getenv("HOME"))) {
  46.         strcpy(schedule_file_name, ".month");
  47.     } else {
  48.         strcpy(schedule_file_name, s);
  49.         strcat(schedule_file_name, "/.month");
  50.     }
  51.  
  52.     rec_size = sizeof(struct event_rec);
  53.  
  54.     if ((fd = open(schedule_file_name, 0)) != -1) {
  55.  
  56.         chain_ptr = &events;
  57.  
  58.         while (read(fd, &event_buf, rec_size) == rec_size) {
  59.             if (event_ptr = (struct event_rec *) malloc(rec_size)) {
  60.                 chain_ptr->next_event = event_ptr;
  61.                 chain_ptr = event_ptr;
  62.                 *chain_ptr = event_buf;
  63.                 chain_ptr->next_event = (struct event_rec *)0;
  64.             } else {
  65.                 break;
  66.             }
  67.         }
  68.         close(fd);
  69.     }
  70. }
  71.  
  72. write_schedule()
  73. {
  74.     int fd;
  75.     struct event_rec *chain_ptr;
  76.  
  77.     updating = 1;
  78.  
  79.     if ((fd = creat(schedule_file_name, 0640)) == -1) {
  80.         return(-1);
  81.     }
  82.     chain_ptr = events.next_event;
  83.  
  84.     while (chain_ptr) {
  85.         if (!is_passed_event(chain_ptr)) {
  86.             write(fd, (char *)chain_ptr, sizeof(struct event_rec));
  87.         }
  88.         chain_ptr = chain_ptr->next_event;
  89.     }
  90.     close(fd);
  91.     updating = 0;
  92.     return(0);
  93. }
  94.  
  95. select_regularity_col(col)
  96. register col;
  97. {
  98.     short i, hflag;
  99.  
  100.     switch(col) {
  101.     case MONTHLY_COL:
  102.         hl_all(¤t_event, (current_event.monthly ? 0 : 1),
  103.             0, -1, -1, -1, -1);
  104.         break;
  105.     case YEARLY_COL:
  106.         hl_all(¤t_event, 0, (current_event.yearly ? 0 : 1),
  107.             -1, -1, -1, -1);
  108.         break;
  109.     case EVERY_COL:
  110.         hl_all(¤t_event, -1, -1,
  111.            (current_event.every ? 0 : 1), -1, -1, -1);
  112.         break;
  113.     case SMTWTFS_COL:
  114.     case SMTWTFS_COL + 3:
  115.     case SMTWTFS_COL + 6:
  116.     case SMTWTFS_COL + 9:
  117.     case SMTWTFS_COL + 12:
  118.     case SMTWTFS_COL + 15:
  119.     case SMTWTFS_COL + 18:
  120.         i = (col - SMTWTFS_COL) / 3;
  121.         hflag = (current_event.smtwtfs[i] = !current_event.smtwtfs[i]);
  122.         hl_schedule(col, hflag);
  123.         hl_all(¤t_event, -1, -1, -1, -1, -1, -1);
  124.         break;
  125.     case NTH_COL:
  126.         hl_all(¤t_event, -1, -1, -1,
  127.             (current_event.nth_is_on ? 0 : 1), -1, -1);
  128.         break;
  129.     case LAST_COL:
  130.         hl_all(¤t_event, -1, -1, -1, -1,
  131.             (current_event.last ? 0 : 1), -1);
  132.         break;
  133.     }
  134. }
  135.  
  136. accept_cancel(is_accept)
  137. short is_accept;
  138. {
  139.     if (is_accept) {
  140.         accept_current_event();
  141.     } else {
  142.         cancel_current_event();
  143.         display_event(¤t_event);
  144.     }
  145.     goto_day(day);
  146. }
  147.  
  148. accept_current_event()
  149. {
  150.     if ((parse_event(¤t_event) != -1)) {
  151.         if (get_answer("Put into schedule? ", "done", "change cancelled")
  152.             == 'y') {
  153.             if (!edit_flag) {
  154.                 link_event(¤t_event);
  155.             }
  156.             put_into_schedule = 1;
  157.         }
  158.     }
  159. }
  160.  
  161. cancel_current_event()
  162. {
  163.     if (!edit_flag) {
  164.         current_event = events;
  165.     }
  166. }
  167.  
  168. link_event(event)
  169. struct event_rec *event;
  170. {
  171.     struct event_rec *t, *ptr;
  172.     char *malloc();
  173.  
  174.     if (!(ptr = (struct event_rec *)
  175.         malloc(sizeof(struct event_rec)))) {
  176.         return;
  177.     }
  178.     *ptr = *event;
  179.     t = events.next_event;
  180.     events.next_event = ptr;
  181.     ptr->next_event = t;
  182.     update_schedule++;
  183. }
  184.  
  185. parse_event(event)
  186. struct event_rec *event;
  187. {
  188.     short hs;
  189.  
  190.     hs = has_smtwtfs(event->smtwtfs);
  191.  
  192.     if ((event->every || event->nth_is_on || event->last) && !hs) {
  193.         error_message("missing day of week", 1);
  194.         return(-1);
  195.     }
  196.     if (hs && !event->every && !event->nth_is_on && !event->last) {
  197. MQ:             error_message("missing qualifier", 1);
  198.         return(-1);
  199.     }
  200.     if (!event->every &&
  201.         (event->monthly || event->yearly) &&
  202.         (event->nth_is_on || event->last)) {
  203.         error_message("need 'every'", 1);
  204.         return(-1);
  205.     }
  206.     if (event->last && !event->monthly && !event->yearly) {
  207.         error_message("monthly or yearly?", 1);
  208.         return(-1);
  209.     }
  210.     if ((event->nth_is_on || event->last) &&
  211.         (!event->monthly && !event->yearly && !event->every)) {
  212.         goto MQ;
  213.     }
  214.     parsed_correctly = 1;
  215.     return(0);
  216. }
  217.  
  218.  
  219. overview()
  220. {
  221.     short i, j, row, col, hour, minute, duration, n;
  222.     struct event_rec *events_today[MAX_DAILY_EVENTS];
  223.     char *grid;
  224.  
  225.     get_daily_events(events_today);
  226.  
  227.     clear_schedule_area();
  228.  
  229.     for (i = 0; i < 4; i++) {
  230.         mvaddstr((SCHEDULE_ROW + i + i), 1, grids[i]);
  231.     }
  232.  
  233.     standout();
  234.     i = 0;
  235.  
  236.     while (events_today[i]) {
  237.  
  238.         hour = events_today[i]->hour;
  239.         minute = events_today[i]->minute;
  240.  
  241.         row = SCHEDULE_ROW + ((hour / 6) * 2);
  242.  
  243.         duration = (events_today[i]->duration_hours * 60) +
  244.             events_today[i]->duration_minutes;
  245.         col = 1 + (12 * (hour % 6)) + (3 * (minute / 15));
  246.         n = hour / 6;
  247.         grid = grids[n];
  248.         duration /= 15;
  249.  
  250.         move(row, col);
  251.  
  252.         for (j = 0; j < duration; j++) {
  253.             addch(grid[col - 1]);
  254.             addch(grid[col]);
  255.             addch(grid[col + 1]);
  256.  
  257.             col += 3;
  258.             if (col > 72) {
  259.                 col = 1;
  260.                 row += 2;
  261.  
  262.                 if (row > (SCHEDULE_ROW + 6)) {
  263.                     row = SCHEDULE_ROW;
  264.                 }
  265.                 move(row, col);
  266.                 grid = grids[++n % 4];
  267.             }
  268.         }
  269.         i++;
  270.     }
  271.     standend();
  272. }
  273.  
  274. get_daily_events(events_today)
  275. struct event_rec *events_today[];
  276. {
  277.     short i = 0;
  278.     struct event_rec *eptr;
  279.  
  280.     eptr = events.next_event;
  281.  
  282.     while (eptr && (i < (MAX_DAILY_EVENTS - 1))) {
  283.         if (event_matches_date(eptr)) {
  284.             if (!events_today) {
  285.                 return(1);
  286.             }
  287.             events_today[i++] = eptr;
  288.         }
  289.         eptr = eptr->next_event;
  290.     }
  291.     if (events_today) {
  292.         events_today[i] = 0;
  293.     }
  294.     return(i);
  295. }
  296.  
  297. scan_today_events()
  298. {
  299.     struct event_rec *events_today[MAX_DAILY_EVENTS];
  300.     short i, j, k, ch, n;
  301.  
  302.     if ((n = get_daily_events(events_today)) <= 0) {
  303.         error_message("No events this day", 0);
  304.         clear_schedule_area();
  305.         return;
  306.     }
  307.     sort_events(events_today, n);
  308.  
  309.     for (i = 0; i < n; i++) {
  310.         current_event = *events_today[i];
  311.         display_event(events_today[i]);
  312. GETCH:
  313.         ch = get_npdeq();
  314.  
  315.         switch(ch) {
  316.         case '\0':
  317.             i--;
  318.             break;
  319.         case '\033':
  320.         case 'q':
  321.             goto OUT;
  322.         case 'n':
  323.             j = i + 1;
  324.             while ((j < n) && (!events_today[j])) {
  325.                 j++;
  326.             }
  327.             if (j >= n) {
  328.                 /*sound_bell();
  329.                 goto GETCH;*/
  330.                 goto OUT;
  331.             }
  332.             i = j - 1;
  333.             break;
  334.         case 'p':
  335.             j = i - 1;
  336.             while ((j >= 0) && (!events_today[j])) {
  337.                 j--;
  338.             }
  339.             if (j < 0) {
  340.                 sound_bell();
  341.                 goto GETCH;
  342.             }
  343.             i = j - 1;
  344.             break;
  345.         case 'd':
  346.             delete_event(events_today[i]);
  347.             events_today[i] = 0;
  348.             for (k = i+1; k < n; k++) {
  349.                 if (events_today[k] != 0) {
  350.                     i = k;
  351.                     break;
  352.                 }
  353.             }
  354.             if (events_today[i] == 0) {
  355.                 for (k = i-1; k >= 0; k--) {
  356.                     if (events_today[k] != 0) {
  357.                         i = k;
  358.                         break;
  359.                     }
  360.                 }
  361.             }
  362.             if (events_today[i] != 0) {
  363.                 i--;
  364.             } else {
  365.                 goto OUT;
  366.             }
  367.             break;
  368.         case 'e':
  369. EDIT:           goto_schedule();
  370.             edit_flag = 1;
  371.             parsed_correctly = 0;
  372.             put_into_schedule = 0;
  373.             if (user() == ACCEPT) {
  374.                 if (parsed_correctly && put_into_schedule) {
  375.                     *events_today[i] = current_event;
  376.                     update_schedule++;
  377.                 } else if (!parsed_correctly) {
  378.                     goto EDIT;
  379.                 }
  380.             } else {
  381.                 display_event(events_today[i]);
  382.             }
  383.             edit_flag = 0;
  384.             i--;
  385.             break;
  386.         }
  387.     }
  388. OUT:    goto_day(day);
  389. }
  390.  
  391. scan_every_event()
  392. {
  393.     register short ch;
  394.     struct event_rec *ptr;
  395.  
  396.     ptr = events.next_event;
  397.  
  398.     while (ptr) {
  399.         current_event = *ptr;
  400.         display_event(ptr);
  401.  
  402.         ch = get_nq();
  403.  
  404.         switch(ch) {
  405.             case 'n':
  406.                 ptr = ptr->next_event;
  407.                 break;
  408.             case 'q':
  409.                 goto RET;
  410.                 break;
  411.         }
  412.     }
  413. RET: ;
  414. }
  415.  
  416. delete_event(event)
  417. struct event_rec *event;
  418. {
  419.     struct event_rec *ptr;
  420.  
  421.     ptr = &events;
  422.  
  423.     while (ptr && (ptr->next_event != event)) {
  424.         ptr = ptr->next_event;
  425.     }
  426.     if (ptr) {
  427.         ptr->next_event = ptr->next_event->next_event;
  428.         free((char *)event);
  429.     }
  430.     update_schedule++;
  431. }
  432.  
  433. sort_events(e, n)
  434. register struct event_rec *e[];
  435. int n;
  436. {
  437.     register struct event_rec *t;
  438.     register i, j;
  439.     short f;
  440.  
  441.     for (i = 0; i < n; i++) {
  442.         for (j = (n - 1), f = 0; j > 0; j--) {
  443.             if ((e[j]->hour < e[j-1]->hour) ||
  444.                 ((e[j]->hour == e[j-1]->hour) &&
  445.                 (e[j]->minute < e[j-1]->minute))) {
  446.                 t = e[j];
  447.                 e[j] = e[j-1];
  448.                 e[j-1] = t;
  449.                 f++;
  450.             }
  451.         }
  452.         if (f == 0) {
  453.             break;
  454.         }
  455.     }
  456. }
  457.  
  458. show_all_events(month, year)
  459. register month, year;
  460. {
  461.     register struct event_rec *eptr;
  462.     short i;
  463.     char match_list[32];
  464.     short tday;
  465.  
  466.     tday = day;
  467.  
  468.     for (i = 1; i <= days; i++) {
  469.  
  470.         eptr = events.next_event;
  471.         match_list[i] = 0;
  472.         day = i;
  473.  
  474.         while (eptr) {
  475.             if (event_matches_date(eptr)) {
  476.                 match_list[i] = 1;
  477.                 break;
  478.             }
  479.             eptr = eptr->next_event;
  480.         }
  481.     }
  482.     day = tday;
  483.     print_cal(month, year, match_list);
  484. }
  485.